package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade PARAMETROS_OPERACOES
 * @author Gerado pelo Telescope
 */
public class EntParametrosOperacoes extends Entity {
    
    public final static String ENTITY_NAME = "RTSYSINF.PARAMETROS_OPERACOES";
    public final static String TABLE_NAME = "PARAMETROS_OPERACOES";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntParametrosOperacoes() {
        super();
        initialize();
    }
    
    public EntParametrosOperacoes(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aSequencia = new DomInteger(this,"SEQUENCIA", "Sequencia"); 
        aSequencia.setRequired(true);
        oSequencia = new DomInteger();
        aParametro = new DomText(this,"PARAMETRO", "Parâmetro"); 
        aParametro.setRequired(true);
        oParametro = new DomText();
        aTitulo = new DomText(this,"TITULO", "Título"); 
        aTitulo.setRequired(true);
        oTitulo = new DomText();
        aDominio = new DomOpcao(this,"DOMINIO", "Domínio"); 
        aDominio.setRequired(true);
        aDominio.setSize(100);
        aDominio.clearOptions();
        aDominio.addOption("ADSRT.DATE", "Data");
        aDominio.addOption("ADSRT.DATE_TIME", "Data e hora");
        aDominio.addOption("ADSRT.INTEGER", "Inteiro");
        aDominio.addOption("ADSRT.OPTION", "Opção");
        aDominio.addOption("ADSRT.VALUE", "Real");
        aDominio.addOption("ADSRT.TEXT", "Texto");
        aDominio.addOption("ADSRT.TEXT_LONG", "Texto com quebras de linha");
        oDominio = new DomOpcao();
        aValorPadrao = new DomText(this,"VALOR_PADRAO", "Valor padrão"); 
        oValorPadrao = new DomText();
        aRequerido = new DomFlag(this,"REQUERIDO", "Requerido"); 
        aRequerido.setRequired(true);
        aRequerido.setDefaultValue("N");
        oRequerido = new DomFlag();
        aOperacaoId = new DomId(this,"OPERACAO_ID", "Operação"); 
        aOperacaoId.setRequired(true);
        oOperacaoId = new DomId();
        aTotalizado = new DomFlag(this,"TOTALIZADO", "Totalizado"); 
        aTotalizado.setRequired(true);
        aTotalizado.setDefaultValue("N");
        oTotalizado = new DomFlag();
        aFiltro = new DomFlag(this,"FILTRO", "Filtro"); 
        aFiltro.setRequired(true);
        aFiltro.setDefaultValue("N");
        oFiltro = new DomFlag();
        aVisivel = new DomFlag(this,"VISIVEL", "Visível"); 
        aVisivel.setRequired(true);
        aVisivel.setDefaultValue("S");
        oVisivel = new DomFlag();
        aFormato = new DomText(this,"FORMATO", "Formato"); 
        aFormato.setSize(4000);
        oFormato = new DomText();
        aAgregacao = new DomOpcao(this,"AGREGACAO", "Agregação"); 
        aAgregacao.setSize(5);
        aAgregacao.clearOptions();
        aAgregacao.addOption("AVG", "Average");
        aAgregacao.addOption("COUNT", "Count");
        aAgregacao.addOption("KEY", "Key");
        aAgregacao.addOption("MAX", "Max");
        aAgregacao.addOption("MIN", "Min");
        aAgregacao.addOption("SUM", "Sum");
        oAgregacao = new DomOpcao();
        aInclusao = new DomOpcao(this,"INCLUSAO", "Inclusão"); 
        aInclusao.setRequired(true);
        aInclusao.setSize(1);
        aInclusao.clearOptions();
        aInclusao.addOption("A", "Automátioo");
        aInclusao.addOption("M", "Manual");
        aInclusao.setDefaultValue("A");
        oInclusao = new DomOpcao();
        aGrafico = new DomOpcao(this,"GRAFICO", "Gráfico"); 
        aGrafico.setSize(4);
        aGrafico.clearOptions();
        aGrafico.addOption("LINE", "Line");
        aGrafico.addOption("X", "X");
        aGrafico.addOption("Y", "Y");
        oGrafico = new DomOpcao();
        aOrdenacaoSeq = new DomInteger(this,"ORDENACAO_SEQ", "Ordenação (seq)"); 
        oOrdenacaoSeq = new DomInteger();
        aOrdenacaoDir = new DomOpcao(this,"ORDENACAO_DIR", "Ordenação (asc/desc)"); 
        aOrdenacaoDir.setSize(1);
        aOrdenacaoDir.clearOptions();
        aOrdenacaoDir.addOption("A", "Asc");
        aOrdenacaoDir.addOption("D", "Desc");
        oOrdenacaoDir = new DomOpcao();
        aOpcoes = new DomTextLong(this,"OPCOES", "Opções"); 
        oOpcoes = new DomTextLong();
        aAgrupador = new DomFlag(this,"AGRUPADOR", "Agrupador"); 
        aAgrupador.setRequired(true);
        aAgrupador.setDefaultValue("N");
        oAgrupador = new DomFlag();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Sequencia
    private DomInteger aSequencia;
    private DomInteger oSequencia;
    
    // Parâmetro
    private DomText aParametro;
    private DomText oParametro;
    
    // Título
    private DomText aTitulo;
    private DomText oTitulo;
    
    // Domínio
    private DomOpcao aDominio;
    private DomOpcao oDominio;
    
    // Valor padrão
    private DomText aValorPadrao;
    private DomText oValorPadrao;
    
    // Requerido
    private DomFlag aRequerido;
    private DomFlag oRequerido;
    
    // Operação
    private DomId aOperacaoId;
    private DomId oOperacaoId;
    
    // Totalizado
    private DomFlag aTotalizado;
    private DomFlag oTotalizado;
    
    // Filtro
    private DomFlag aFiltro;
    private DomFlag oFiltro;
    
    // Visível
    private DomFlag aVisivel;
    private DomFlag oVisivel;
    
    // Formato
    private DomText aFormato;
    private DomText oFormato;
    
    // Agregação
    private DomOpcao aAgregacao;
    private DomOpcao oAgregacao;
    
    // Inclusão
    private DomOpcao aInclusao;
    private DomOpcao oInclusao;
    
    // Gráfico
    private DomOpcao aGrafico;
    private DomOpcao oGrafico;
    
    // Ordenação (seq)
    private DomInteger aOrdenacaoSeq;
    private DomInteger oOrdenacaoSeq;
    
    // Ordenação (asc/desc)
    private DomOpcao aOrdenacaoDir;
    private DomOpcao oOrdenacaoDir;
    
    // Opções
    private DomTextLong aOpcoes;
    private DomTextLong oOpcoes;
    
    // Agrupador
    private DomFlag aAgrupador;
    private DomFlag oAgrupador;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntParametrosOperacoes id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA">
    
    public EntParametrosOperacoes sequencia(Integer value) {
        setSequencia(value);
        return this;
    }
    
    public void setSequencia(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value.getValue());
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(String value) {
        if (value == null) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value);
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(Integer value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequencia(Object value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequencia() {
        if (!aSequencia.isNull()) {
            aSequencia.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getSequencia() {
        return aSequencia;
    }
    
    public DomInteger oldSequencia() {
        return oSequencia;
    }
    
    public Integer valueOfSequencia() {
        return aSequencia.getValue();
    }
    
    public boolean isSequenciaModified() {
        return aSequencia.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PARAMETRO">
    
    public EntParametrosOperacoes parametro(String value) {
        setParametro(value);
        return this;
    }
    
    public void setParametro(DomText value) {
        if (value == null || value.isNull()) {
            nullifyParametro();
        } else {
            aParametro.setValue(value.getValue());
            if (aParametro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParametro(String value) {
        if (value == null) {
            nullifyParametro();
        } else {
            aParametro.setValue(value);
            if (aParametro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParametro(Object value) {
        aParametro.setValue(value);
        if (aParametro.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyParametro() {
        if (!aParametro.isNull()) {
            aParametro.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getParametro() {
        return aParametro;
    }
    
    public DomText oldParametro() {
        return oParametro;
    }
    
    public String valueOfParametro() {
        return aParametro.getValue();
    }
    
    public boolean isParametroModified() {
        return aParametro.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TITULO">
    
    public EntParametrosOperacoes titulo(String value) {
        setTitulo(value);
        return this;
    }
    
    public void setTitulo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value.getValue());
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(String value) {
        if (value == null) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value);
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(Object value) {
        aTitulo.setValue(value);
        if (aTitulo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTitulo() {
        if (!aTitulo.isNull()) {
            aTitulo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getTitulo() {
        return aTitulo;
    }
    
    public DomText oldTitulo() {
        return oTitulo;
    }
    
    public String valueOfTitulo() {
        return aTitulo.getValue();
    }
    
    public boolean isTituloModified() {
        return aTitulo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DOMINIO">
    
    public EntParametrosOperacoes dominio(String value) {
        setDominio(value);
        return this;
    }
    
    public void setDominio(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyDominio();
        } else {
            aDominio.setValue(value.getValue());
            if (aDominio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDominio(String value) {
        if (value == null) {
            nullifyDominio();
        } else {
            aDominio.setValue(value);
            if (aDominio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDominio(Object value) {
        aDominio.setValue(value);
        if (aDominio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDominio() {
        if (!aDominio.isNull()) {
            aDominio.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getDominio() {
        return aDominio;
    }
    
    public DomOpcao oldDominio() {
        return oDominio;
    }
    
    public String valueOfDominio() {
        return aDominio.getValue();
    }
    
    public boolean isDominioModified() {
        return aDominio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_PADRAO">
    
    public EntParametrosOperacoes valorPadrao(String value) {
        setValorPadrao(value);
        return this;
    }
    
    public void setValorPadrao(DomText value) {
        if (value == null || value.isNull()) {
            nullifyValorPadrao();
        } else {
            aValorPadrao.setValue(value.getValue());
            if (aValorPadrao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorPadrao(String value) {
        if (value == null) {
            nullifyValorPadrao();
        } else {
            aValorPadrao.setValue(value);
            if (aValorPadrao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorPadrao(Object value) {
        aValorPadrao.setValue(value);
        if (aValorPadrao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorPadrao() {
        if (!aValorPadrao.isNull()) {
            aValorPadrao.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getValorPadrao() {
        return aValorPadrao;
    }
    
    public DomText oldValorPadrao() {
        return oValorPadrao;
    }
    
    public String valueOfValorPadrao() {
        return aValorPadrao.getValue();
    }
    
    public boolean isValorPadraoModified() {
        return aValorPadrao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo REQUERIDO">
    
    public EntParametrosOperacoes requerido(String value) {
        setRequerido(value);
        return this;
    }
    
    public void setRequerido(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyRequerido();
        } else {
            aRequerido.setValue(value.getValue());
            if (aRequerido.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRequerido(String value) {
        if (value == null) {
            nullifyRequerido();
        } else {
            aRequerido.setValue(value);
            if (aRequerido.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRequerido(Object value) {
        aRequerido.setValue(value);
        if (aRequerido.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyRequerido() {
        if (!aRequerido.isNull()) {
            aRequerido.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getRequerido() {
        return aRequerido;
    }
    
    public DomFlag oldRequerido() {
        return oRequerido;
    }
    
    public String valueOfRequerido() {
        return aRequerido.getValue();
    }
    
    public boolean isRequeridoModified() {
        return aRequerido.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo OPERACAO_ID">
    
    public EntParametrosOperacoes operacaoId(Long value) {
        setOperacaoId(value);
        return this;
    }
    
    public void setOperacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyOperacaoId();
        } else {
            aOperacaoId.setValue(value.getValue());
            if (aOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperacaoId(String value) {
        if (value == null) {
            nullifyOperacaoId();
        } else {
            aOperacaoId.setValue(value);
            if (aOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperacaoId(Long value) {
        aOperacaoId.setValue(value);
        if (aOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setOperacaoId(Object value) {
        aOperacaoId.setValue(value);
        if (aOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOperacaoId() {
        if (!aOperacaoId.isNull()) {
            aOperacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getOperacaoId() {
        return aOperacaoId;
    }
    
    public DomId oldOperacaoId() {
        return oOperacaoId;
    }
    
    public Long valueOfOperacaoId() {
        return aOperacaoId.getValue();
    }
    
    public boolean isOperacaoIdModified() {
        return aOperacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TOTALIZADO">
    
    public EntParametrosOperacoes totalizado(String value) {
        setTotalizado(value);
        return this;
    }
    
    public void setTotalizado(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyTotalizado();
        } else {
            aTotalizado.setValue(value.getValue());
            if (aTotalizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTotalizado(String value) {
        if (value == null) {
            nullifyTotalizado();
        } else {
            aTotalizado.setValue(value);
            if (aTotalizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTotalizado(Object value) {
        aTotalizado.setValue(value);
        if (aTotalizado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTotalizado() {
        if (!aTotalizado.isNull()) {
            aTotalizado.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getTotalizado() {
        return aTotalizado;
    }
    
    public DomFlag oldTotalizado() {
        return oTotalizado;
    }
    
    public String valueOfTotalizado() {
        return aTotalizado.getValue();
    }
    
    public boolean isTotalizadoModified() {
        return aTotalizado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FILTRO">
    
    public EntParametrosOperacoes filtro(String value) {
        setFiltro(value);
        return this;
    }
    
    public void setFiltro(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyFiltro();
        } else {
            aFiltro.setValue(value.getValue());
            if (aFiltro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFiltro(String value) {
        if (value == null) {
            nullifyFiltro();
        } else {
            aFiltro.setValue(value);
            if (aFiltro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFiltro(Object value) {
        aFiltro.setValue(value);
        if (aFiltro.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFiltro() {
        if (!aFiltro.isNull()) {
            aFiltro.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getFiltro() {
        return aFiltro;
    }
    
    public DomFlag oldFiltro() {
        return oFiltro;
    }
    
    public String valueOfFiltro() {
        return aFiltro.getValue();
    }
    
    public boolean isFiltroModified() {
        return aFiltro.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VISIVEL">
    
    public EntParametrosOperacoes visivel(String value) {
        setVisivel(value);
        return this;
    }
    
    public void setVisivel(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyVisivel();
        } else {
            aVisivel.setValue(value.getValue());
            if (aVisivel.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVisivel(String value) {
        if (value == null) {
            nullifyVisivel();
        } else {
            aVisivel.setValue(value);
            if (aVisivel.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVisivel(Object value) {
        aVisivel.setValue(value);
        if (aVisivel.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVisivel() {
        if (!aVisivel.isNull()) {
            aVisivel.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getVisivel() {
        return aVisivel;
    }
    
    public DomFlag oldVisivel() {
        return oVisivel;
    }
    
    public String valueOfVisivel() {
        return aVisivel.getValue();
    }
    
    public boolean isVisivelModified() {
        return aVisivel.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMATO">
    
    public EntParametrosOperacoes formato(String value) {
        setFormato(value);
        return this;
    }
    
    public void setFormato(DomText value) {
        if (value == null || value.isNull()) {
            nullifyFormato();
        } else {
            aFormato.setValue(value.getValue());
            if (aFormato.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormato(String value) {
        if (value == null) {
            nullifyFormato();
        } else {
            aFormato.setValue(value);
            if (aFormato.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormato(Object value) {
        aFormato.setValue(value);
        if (aFormato.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormato() {
        if (!aFormato.isNull()) {
            aFormato.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getFormato() {
        return aFormato;
    }
    
    public DomText oldFormato() {
        return oFormato;
    }
    
    public String valueOfFormato() {
        return aFormato.getValue();
    }
    
    public boolean isFormatoModified() {
        return aFormato.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo AGREGACAO">
    
    public EntParametrosOperacoes agregacao(String value) {
        setAgregacao(value);
        return this;
    }
    
    public void setAgregacao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyAgregacao();
        } else {
            aAgregacao.setValue(value.getValue());
            if (aAgregacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAgregacao(String value) {
        if (value == null) {
            nullifyAgregacao();
        } else {
            aAgregacao.setValue(value);
            if (aAgregacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAgregacao(Object value) {
        aAgregacao.setValue(value);
        if (aAgregacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAgregacao() {
        if (!aAgregacao.isNull()) {
            aAgregacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getAgregacao() {
        return aAgregacao;
    }
    
    public DomOpcao oldAgregacao() {
        return oAgregacao;
    }
    
    public String valueOfAgregacao() {
        return aAgregacao.getValue();
    }
    
    public boolean isAgregacaoModified() {
        return aAgregacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INCLUSAO">
    
    public EntParametrosOperacoes inclusao(String value) {
        setInclusao(value);
        return this;
    }
    
    public void setInclusao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyInclusao();
        } else {
            aInclusao.setValue(value.getValue());
            if (aInclusao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInclusao(String value) {
        if (value == null) {
            nullifyInclusao();
        } else {
            aInclusao.setValue(value);
            if (aInclusao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInclusao(Object value) {
        aInclusao.setValue(value);
        if (aInclusao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyInclusao() {
        if (!aInclusao.isNull()) {
            aInclusao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getInclusao() {
        return aInclusao;
    }
    
    public DomOpcao oldInclusao() {
        return oInclusao;
    }
    
    public String valueOfInclusao() {
        return aInclusao.getValue();
    }
    
    public boolean isInclusaoModified() {
        return aInclusao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo GRAFICO">
    
    public EntParametrosOperacoes grafico(String value) {
        setGrafico(value);
        return this;
    }
    
    public void setGrafico(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyGrafico();
        } else {
            aGrafico.setValue(value.getValue());
            if (aGrafico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setGrafico(String value) {
        if (value == null) {
            nullifyGrafico();
        } else {
            aGrafico.setValue(value);
            if (aGrafico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setGrafico(Object value) {
        aGrafico.setValue(value);
        if (aGrafico.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyGrafico() {
        if (!aGrafico.isNull()) {
            aGrafico.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getGrafico() {
        return aGrafico;
    }
    
    public DomOpcao oldGrafico() {
        return oGrafico;
    }
    
    public String valueOfGrafico() {
        return aGrafico.getValue();
    }
    
    public boolean isGraficoModified() {
        return aGrafico.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ORDENACAO_SEQ">
    
    public EntParametrosOperacoes ordenacaoSeq(Integer value) {
        setOrdenacaoSeq(value);
        return this;
    }
    
    public void setOrdenacaoSeq(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyOrdenacaoSeq();
        } else {
            aOrdenacaoSeq.setValue(value.getValue());
            if (aOrdenacaoSeq.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdenacaoSeq(String value) {
        if (value == null) {
            nullifyOrdenacaoSeq();
        } else {
            aOrdenacaoSeq.setValue(value);
            if (aOrdenacaoSeq.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdenacaoSeq(Integer value) {
        aOrdenacaoSeq.setValue(value);
        if (aOrdenacaoSeq.isModified()) {
            setModified(true);
        }
    }
    
    public void setOrdenacaoSeq(Object value) {
        aOrdenacaoSeq.setValue(value);
        if (aOrdenacaoSeq.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOrdenacaoSeq() {
        if (!aOrdenacaoSeq.isNull()) {
            aOrdenacaoSeq.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getOrdenacaoSeq() {
        return aOrdenacaoSeq;
    }
    
    public DomInteger oldOrdenacaoSeq() {
        return oOrdenacaoSeq;
    }
    
    public Integer valueOfOrdenacaoSeq() {
        return aOrdenacaoSeq.getValue();
    }
    
    public boolean isOrdenacaoSeqModified() {
        return aOrdenacaoSeq.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ORDENACAO_DIR">
    
    public EntParametrosOperacoes ordenacaoDir(String value) {
        setOrdenacaoDir(value);
        return this;
    }
    
    public void setOrdenacaoDir(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyOrdenacaoDir();
        } else {
            aOrdenacaoDir.setValue(value.getValue());
            if (aOrdenacaoDir.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdenacaoDir(String value) {
        if (value == null) {
            nullifyOrdenacaoDir();
        } else {
            aOrdenacaoDir.setValue(value);
            if (aOrdenacaoDir.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdenacaoDir(Object value) {
        aOrdenacaoDir.setValue(value);
        if (aOrdenacaoDir.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOrdenacaoDir() {
        if (!aOrdenacaoDir.isNull()) {
            aOrdenacaoDir.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getOrdenacaoDir() {
        return aOrdenacaoDir;
    }
    
    public DomOpcao oldOrdenacaoDir() {
        return oOrdenacaoDir;
    }
    
    public String valueOfOrdenacaoDir() {
        return aOrdenacaoDir.getValue();
    }
    
    public boolean isOrdenacaoDirModified() {
        return aOrdenacaoDir.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo OPCOES">
    
    public EntParametrosOperacoes opcoes(String value) {
        setOpcoes(value);
        return this;
    }
    
    public void setOpcoes(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyOpcoes();
        } else {
            aOpcoes.setValue(value.getValue());
            if (aOpcoes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOpcoes(String value) {
        if (value == null) {
            nullifyOpcoes();
        } else {
            aOpcoes.setValue(value);
            if (aOpcoes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOpcoes(Object value) {
        aOpcoes.setValue(value);
        if (aOpcoes.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOpcoes() {
        if (!aOpcoes.isNull()) {
            aOpcoes.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getOpcoes() {
        return aOpcoes;
    }
    
    public DomTextLong oldOpcoes() {
        return oOpcoes;
    }
    
    public String valueOfOpcoes() {
        return aOpcoes.getValue();
    }
    
    public boolean isOpcoesModified() {
        return aOpcoes.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo AGRUPADOR">
    
    public EntParametrosOperacoes agrupador(String value) {
        setAgrupador(value);
        return this;
    }
    
    public void setAgrupador(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyAgrupador();
        } else {
            aAgrupador.setValue(value.getValue());
            if (aAgrupador.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAgrupador(String value) {
        if (value == null) {
            nullifyAgrupador();
        } else {
            aAgrupador.setValue(value);
            if (aAgrupador.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAgrupador(Object value) {
        aAgrupador.setValue(value);
        if (aAgrupador.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAgrupador() {
        if (!aAgrupador.isNull()) {
            aAgrupador.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getAgrupador() {
        return aAgrupador;
    }
    
    public DomFlag oldAgrupador() {
        return oAgrupador;
    }
    
    public String valueOfAgrupador() {
        return aAgrupador.getValue();
    }
    
    public boolean isAgrupadorModified() {
        return aAgrupador.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("RTSYSINF.PARAMETROS_OPERACOES.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_PAROPR_NOME_OPERACAO") >= 0) {
                e = new AdsException("RTSYSINF.PARAMETROS_OPERACOES.UK_PAROPR_NOME_OPERACAO", 
                        Severity.ERROR,
                        "Registro duplicado! Chave única Parâmetro ${PARAMETRO}, Operação ${OPERACAO_ID} (UK_PAROPR_NOME_OPERACAO)");
                return e;
            } else if (msg.indexOf("PK_PAROPR") >= 0) {
                e = new AdsException("RTSYSINF.PARAMETROS_OPERACOES.PK_PAROPR", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PAROPR)");
                return e;
            } else if (msg.indexOf("FK_PAROPR_OPERACAO") >= 0) {
                e = new AdsException("RTSYSINF.PARAMETROS_OPERACOES.FK_PAROPR_OPERACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para OPERACAO! (FK_PAROPR_OPERACAO)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.PARAMETROS_OPERACOES.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aSequencia);
            allAttributes.add(aParametro);
            allAttributes.add(aTitulo);
            allAttributes.add(aDominio);
            allAttributes.add(aValorPadrao);
            allAttributes.add(aRequerido);
            allAttributes.add(aOperacaoId);
            allAttributes.add(aTotalizado);
            allAttributes.add(aFiltro);
            allAttributes.add(aVisivel);
            allAttributes.add(aFormato);
            allAttributes.add(aAgregacao);
            allAttributes.add(aInclusao);
            allAttributes.add(aGrafico);
            allAttributes.add(aOrdenacaoSeq);
            allAttributes.add(aOrdenacaoDir);
            allAttributes.add(aOpcoes);
            allAttributes.add(aAgrupador);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getParametro().toString() +
                " " + getOperacaoId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByParametroOperacaoId(String parametro, long operacaoId) throws AdsException {
        findBy(new String[] {"PARAMETRO", "OPERACAO_ID"},
                new Object[] {parametro, operacaoId});
    }
    
    private EntOperacoesSistemas eOperacao;
    
    public EntOperacoesSistemas findOperacao() throws AdsException {
        if (getOperacaoId().isNull()) {
            return null;
        }
        if (eOperacao == null || !valueOfOperacaoId().equals(eOperacao.valueOfId())) {
            eOperacao = new EntOperacoesSistemas(ctx);
            eOperacao.find(valueOfOperacaoId());
        }
        return eOperacao;
    }
    
    /**
     * Ativa o join desta entidade com OPERACOES_SISTEMAS
     * através do atributo OPERACAO_ID
     */
    public EntOperacoesSistemas joinOperacao() {
        return joinOperacao(null);
    }
    public EntOperacoesSistemas joinOperacao(String alias) {
        EntOperacoesSistemas entity = new EntOperacoesSistemas(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getOperacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByOperacao(long id, String sqlAppend) throws AdsException {
        find("select ID from PARAMETROS_OPERACOES where OPERACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByOperacao(long id) throws AdsException {
        findByOperacao(id,"");
    }
    
    public void findByOperacao(Entity entidade) throws AdsException {
        findByOperacao(entidade.valueOfId(),"");
    }
    
    public void findByOperacao(Entity entidade, String sqlAppend) throws AdsException {
        findByOperacao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eOperacao = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oAgrupador.setValue(aAgrupador);
        oDominio.setValue(aDominio);
        oOrdenacaoDir.setValue(aOrdenacaoDir);
        oOrdenacaoSeq.setValue(aOrdenacaoSeq);
        oRequerido.setValue(aRequerido);
        oParametro.setValue(aParametro);
        oValorPadrao.setValue(aValorPadrao);
        oOperacaoId.setValue(aOperacaoId);
        oSequencia.setValue(aSequencia);
        oId.setValue(aId);
        oTitulo.setValue(aTitulo);
        oTotalizado.setValue(aTotalizado);
        oFiltro.setValue(aFiltro);
        oVisivel.setValue(aVisivel);
        oFormato.setValue(aFormato);
        oAgregacao.setValue(aAgregacao);
        oInclusao.setValue(aInclusao);
        oOpcoes.setValue(aOpcoes);
        oGrafico.setValue(aGrafico);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setName("PK_PAROPR");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setName("UK_PAROPR_NOME_OPERACAO");
            rule.addAttribute(new DomText("PARAMETRO",""));
            rule.addAttribute(new DomId("OPERACAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setAssociatedEntity(EntOperacoesSistemas.class);
            rule.setName("FK_PAROPR_OPERACAO");
            rule.addAttribute(new DomId("OPERACAO_ID",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setCheckAttribute(new DomOpcao("DOMINIO",""));
            rule.setName("CKAV_2938124");
            rule.addAllowableValues(new String[] {"ADSRT.DATE", "ADSRT.DATE_TIME", "ADSRT.INTEGER", "ADSRT.OPTION", "ADSRT.TEXT", "ADSRT.TEXT_LONG", "ADSRT.VALUE"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setCheckAttribute(new DomOpcao("AGREGACAO",""));
            rule.setName("CKAV_2946506");
            rule.addAllowableValues(new String[] {"AVG", "COUNT", "KEY", "MAX", "MIN", "SUM"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setCheckAttribute(new DomOpcao("INCLUSAO",""));
            rule.setName("CKAV_3461135");
            rule.addAllowableValues(new String[] {"A", "M"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setCheckAttribute(new DomOpcao("GRAFICO",""));
            rule.setName("CKAV_7471190");
            rule.addAllowableValues(new String[] {"LINE", "X", "Y"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntParametrosOperacoes.class);
            rule.setCheckAttribute(new DomOpcao("ORDENACAO_DIR",""));
            rule.setName("CKAV_5838088");
            rule.addAllowableValues(new String[] {"A", "D"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getAgrupador().isNull()) {
            setAgrupador(getAgrupador().getDefaultValue());
        }
        if (getRequerido().isNull()) {
            setRequerido(getRequerido().getDefaultValue());
        }
        if (getTotalizado().isNull()) {
            setTotalizado(getTotalizado().getDefaultValue());
        }
        if (getFiltro().isNull()) {
            setFiltro(getFiltro().getDefaultValue());
        }
        if (getVisivel().isNull()) {
            setVisivel(getVisivel().getDefaultValue());
        }
        if (getInclusao().isNull()) {
            setInclusao(getInclusao().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
